package mx.ipn.negocios.empleado;

import mx.ipn.negocios.CodigosDeError;
import mx.ipn.negocios.ConexionConPersistencia;
import mx.ipn.to.FechaHoraTO;
import mx.ipn.to.TransferObject;
import mx.ipn.to.EmpleadoTO;
import mx.ipn.to.ColoniaTO;
import mx.ipn.to.ColoniaCalleTO;
import mx.ipn.to.PersonaTO;
import mx.ipn.to.ResponsableTO;
import mx.ipn.to.MunicipioTO;
import mx.ipn.to.BitacoraResponsableTO;
import mx.ipn.to.BitacoraEmpleadoTO;
import mx.ipn.to.DireccionTO;
import mx.ipn.to.GrupoUsuarioTO;
import mx.ipn.to.UsuarioTO;

public class EmpleadoBO {

	public static EmpleadoTO[] buscarEmpleadosActivos() {
		EmpleadoTO[] arrEmpleadoTO = null;
		arrEmpleadoTO = (EmpleadoTO[]) ConexionConPersistencia.invocaServicio(
				"buscarEmpleadosActivos", EmpleadoTO[].class);
		if (arrEmpleadoTO != null) {
			if (arrEmpleadoTO[0].getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = null;
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			}
		} else {
			arrEmpleadoTO = null;
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static ColoniaTO[] buscarColoniasPorMunicipio(int idMunicipio) {
		ColoniaTO[] arrColoniaTO = null;
		ColoniaTO reciveTO = null;
		reciveTO = (ColoniaTO) ConexionConPersistencia.invocaServicio(
				"buscarColoniasPorMunicipio", idMunicipio, ColoniaTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				arrColoniaTO = null;
				arrColoniaTO = new ColoniaTO[1];
				ColoniaTO auxTO = new ColoniaTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrColoniaTO[0] = auxTO;
			} else {
				arrColoniaTO = new ColoniaTO[reciveTO.getListIdColonia().length];
				for (int x = 0; x < reciveTO.getListIdColonia().length; x++) {
					ColoniaTO auxTO = new ColoniaTO();
					auxTO.setIdColonia(reciveTO.getListIdColonia()[x]);
					try {
						auxTO
								.setCodigoPostal(reciveTO.getListCodigoPostal()[x]);
					} catch (Exception e) {
						auxTO.setCodigoPostal("S/C");
					}
					auxTO.setNombre(reciveTO.getListNombre()[x]);
					arrColoniaTO[x] = auxTO;
				}
			}
		} else {
			arrColoniaTO = null;
			arrColoniaTO = new ColoniaTO[1];
			ColoniaTO auxTO = new ColoniaTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrColoniaTO[0] = auxTO;
		}

		return arrColoniaTO;
	}

	public static ColoniaCalleTO buscarCallesPorColonia(int idColonia) {
		// CalleTO[] arrCalleTO = null;
		ColoniaCalleTO reciveTO = null;
		reciveTO = (ColoniaCalleTO) ConexionConPersistencia.invocaServicio(
				"buscarCallesPorColonia", idColonia, ColoniaCalleTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				// arrCalleTO = null;
				// arrCalleTO = new CalleTO[1];
				ColoniaCalleTO auxTO = new ColoniaCalleTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				reciveTO = null;
				reciveTO = auxTO;
				// arrCalleTO[0] = auxTO;
			} else {
				// arrCalleTO = reciveTO.getListCalleTO().clone();
			}
		} else {
			// arrCalleTO = null;
			// arrCalleTO = new CalleTO[1];
			ColoniaCalleTO auxTO = new ColoniaCalleTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(32001));
			reciveTO = null;
			reciveTO = auxTO;
			// arrCalleTO[0] = auxTO;
		}

		// return arrCalleTO;
		return reciveTO;
	}

	public static EmpleadoTO[] jefeDistintoActivo() {
		EmpleadoTO[] arrEmpleadoTO = null;
		arrEmpleadoTO = (EmpleadoTO[]) ConexionConPersistencia.invocaServicio(
				"jefeDistintoActivo", EmpleadoTO[].class);
		if (arrEmpleadoTO != null) {
			if (arrEmpleadoTO[0].getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = null;
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			}
		} else {
			arrEmpleadoTO = null;
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static EmpleadoTO[] encontrarEmpleadoActivoPorCURP(String curp) {
		EmpleadoTO[] arrEmpleadoTO = null;
		EmpleadoTO reciveTO = null;
		reciveTO = (EmpleadoTO) ConexionConPersistencia.invocaServicio(
				"encontrarEmpleadoActivoPorCURP", curp, EmpleadoTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			} else {
				arrEmpleadoTO = new EmpleadoTO[1];
				arrEmpleadoTO[0] = reciveTO;
			}
		} else {
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static EmpleadoTO[] encontrarEmpleadosActivosPorPaterno(
			String paterno) {
		EmpleadoTO[] arrEmpleadoTO = null;
		arrEmpleadoTO = (EmpleadoTO[]) ConexionConPersistencia.invocaServicio(
				"encontrarEmpleadosActivosPorPaterno", paterno,
				EmpleadoTO[].class);
		if (arrEmpleadoTO != null) {
			if (arrEmpleadoTO[0].getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = null;
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			}
		} else {
			arrEmpleadoTO = null;
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static EmpleadoTO[] encontrarEmpleadosActivosPorNombrePaterno(
			PersonaTO personaTO) {
		EmpleadoTO[] arrEmpleadoTO = null;
		arrEmpleadoTO = (EmpleadoTO[]) ConexionConPersistencia.invocaServicio(
				"encontrarEmpleadosActivosPorNombrePaterno", personaTO,
				EmpleadoTO[].class);
		if (arrEmpleadoTO != null) {
			if (arrEmpleadoTO[0].getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = null;
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			}
		} else {
			arrEmpleadoTO = null;
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static EmpleadoTO[] encontrarEmpleadoActivoPorNss(String nss) {
		EmpleadoTO[] arrEmpleadoTO = null;
		EmpleadoTO reciveTO = null;
		reciveTO = (EmpleadoTO) ConexionConPersistencia.invocaServicio(
				"encontrarEmpleadoActivoPorNss", nss, EmpleadoTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			} else {
				arrEmpleadoTO = new EmpleadoTO[1];
				arrEmpleadoTO[0] = reciveTO;
			}
		} else {
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static EmpleadoTO[] encontrarEmpleadosActivosPorPuesto(short idPuesto) {
		EmpleadoTO[] arrEmpleadoTO = null;
		EmpleadoTO reciveTO = null;
		reciveTO = (EmpleadoTO) ConexionConPersistencia.invocaServicio(
				"encontrarEmpleadosActivosPorPuesto", idPuesto,
				EmpleadoTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			} else {
				arrEmpleadoTO = new EmpleadoTO[reciveTO.getListIdEmpleado().length];
				for (int x = 0; x < reciveTO.getListIdEmpleado().length; x++) {
					EmpleadoTO auxTO = new EmpleadoTO();
					auxTO.setIdEmpleado(reciveTO.getListIdEmpleado()[x]);
					auxTO.setNss(reciveTO.getListNss()[x]);
					auxTO.setPersonaTO(reciveTO.getListPersonaTO()[x]);
					auxTO.setFechaIngreso(reciveTO.getListFechaIngreso()[x]);
					auxTO
							.setDiasVacaciones(reciveTO.getListDiasVacaciones()[x]);
					auxTO.setActivo(reciveTO.getListActivo()[x]);
					auxTO.setPuestoTO(reciveTO.getPuestoTO());
					arrEmpleadoTO[x] = auxTO;
				}
			}
		} else {
			arrEmpleadoTO = null;
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static EmpleadoTO[] encontrarEmpleadosActivosPorJefe(int idJefe) {
		EmpleadoTO[] arrEmpleadoTO = null;
		ResponsableTO reciveTO = null;
		reciveTO = (ResponsableTO) ConexionConPersistencia
				.invocaServicio("encontrarEmpleadosActivosPorJefe", idJefe,
						ResponsableTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				arrEmpleadoTO = new EmpleadoTO[1];
				EmpleadoTO auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrEmpleadoTO[0] = auxTO;
			} else {
				arrEmpleadoTO = reciveTO.getListEmpleadoSubordinadoTO().clone();
			}
		} else {
			arrEmpleadoTO = null;
			arrEmpleadoTO = new EmpleadoTO[1];
			EmpleadoTO auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrEmpleadoTO[0] = auxTO;
		}

		return arrEmpleadoTO;
	}

	public static EmpleadoTO encontrarJefeActivoPorSubordinado(int idSubordinado) {
		EmpleadoTO empleadoTO = null;
		ResponsableTO reciveTO = null;
		reciveTO = (ResponsableTO) ConexionConPersistencia.invocaServicio(
				"encontrarJefeActivoPorSubordinado", idSubordinado,
				ResponsableTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				empleadoTO = new EmpleadoTO();
				empleadoTO.setTipoError(TransferObject.INFO);
				empleadoTO.setError(CodigosDeError.error.get(32001));
			} else {
				empleadoTO = reciveTO.getListEmpleadoJefeTO()[0];
			}
		} else {
			empleadoTO = null;
			empleadoTO = new EmpleadoTO();
			empleadoTO.setTipoError(TransferObject.INFO);
			empleadoTO.setError(CodigosDeError.error.get(31010));
		}

		return empleadoTO;
	}

	public static MunicipioTO[] seleccionarMunicipiosPorEstado(short idEstado) {
		MunicipioTO[] arrMunicipioTO = null;
		MunicipioTO reciveTO = null;
		reciveTO = (MunicipioTO) ConexionConPersistencia.invocaServicio(
				"seleccionarMunicipiosPorEstado", idEstado, MunicipioTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() == TransferObject.INFO) {
				arrMunicipioTO = null;
				arrMunicipioTO = new MunicipioTO[1];
				MunicipioTO auxTO = new MunicipioTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32001));
				arrMunicipioTO[0] = auxTO;
			} else {
				arrMunicipioTO = new MunicipioTO[reciveTO.getListIdMunicipio().length];
				for (int x = 0; x < reciveTO.getListIdMunicipio().length; x++) {
					MunicipioTO auxTO = new MunicipioTO();
					auxTO.setIdMunicipio(reciveTO.getListIdMunicipio()[x]);
					auxTO.setNombre(reciveTO.getListNombre()[x]);
					arrMunicipioTO[x] = auxTO;
				}
			}
		} else {
			arrMunicipioTO = null;
			arrMunicipioTO = new MunicipioTO[1];
			MunicipioTO auxTO = new MunicipioTO();
			auxTO.setTipoError(TransferObject.INFO);
			auxTO.setError(CodigosDeError.error.get(31010));
			arrMunicipioTO[0] = auxTO;
		}

		return arrMunicipioTO;
	}

	public static String primeraVocalEncontrada(String cadena) {
		int y = 1;
		String regreso = null;
		for (int x = 0; x < cadena.length(); x++) {
			regreso = cadena.substring(x, y);
			regreso = regreso.toUpperCase();
			if (regreso.compareTo("A") == 0 || regreso.compareTo("E") == 0
					|| regreso.compareTo("I") == 0
					|| regreso.compareTo("O") == 0
					|| regreso.compareTo("U") == 0)
				x = cadena.length();
			else
				y++;
		}

		return regreso;
	}

	public static String primeraConsonanteEncontrada(String cadena) {
		int y = 1;
		String regreso = null;
		for (int x = 0; x < cadena.length(); x++) {
			regreso = cadena.substring(x, y);
			regreso = regreso.toUpperCase();
			if (regreso.compareTo("A") == 0 || regreso.compareTo("E") == 0
					|| regreso.compareTo("I") == 0
					|| regreso.compareTo("O") == 0
					|| regreso.compareTo("U") == 0)
				y++;
			else
				x = cadena.length();
		}

		return regreso;
	}

	public static String calcularCurp(PersonaTO curpTO) {
		String curp = null;
		if (curpTO != null) {
			String fecha = null;

			String paterno;
			if (curpTO.getApellidoPaterno() == null)
				paterno = "**";
			else
				paterno = curpTO.getApellidoPaterno().replace(" ", "");

			curp = paterno.substring(0, 1);
			curp = curp
					+ primeraVocalEncontrada(paterno.substring(1, paterno
							.length()));
			String materno;
			if (curpTO.getApellidoMaterno() == null)
				materno = "**";
			else
				materno = curpTO.getApellidoMaterno().replace(" ", "");

			curp = curp + materno.substring(0, 1);

			String nombre;
			if (curpTO.getNombre() == null)
				nombre = "**";
			else
				nombre = curpTO.getNombre().replace(" ", "");

			curp = curp + nombre.substring(0, 1);

			fecha = FechaHoraTO.getFecha(curpTO.getFechaNacimiento())
					.toString();

			curp = curp + fecha.substring(2, 4);
			curp = curp + fecha.substring(5, 7);
			curp = curp + fecha.substring(8, fecha.length());

			if (curpTO.isSexo() == false)
				curp = curp + "h";
			else
				curp = curp + "m";
			curp = curp + "**";

			curp = curp
					+ primeraConsonanteEncontrada(paterno.substring(1, paterno
							.length()));
			curp = curp
					+ primeraConsonanteEncontrada(materno.substring(1, materno
							.length()));
			curp = curp
					+ primeraConsonanteEncontrada(nombre.substring(1, nombre
							.length()));

			curp = curp + "99";

		}

		return curp.toUpperCase();
	}

	public static EmpleadoTO bajaEmpleado(EmpleadoTO bajaTO) {
		EmpleadoTO auxTO = null;
		ResponsableTO reciveTO = null;
		boolean bandera1 = false;

		if (bajaTO.getTipoError() == TransferObject.CONFIRMACION) {
			bandera1 = true;
			reciveTO = (ResponsableTO) ConexionConPersistencia.invocaServicio(
					"encontrarEmpleadosActivosPorJefe", bajaTO.getIdEmpleado(),
					ResponsableTO.class);

			if (reciveTO != null) {
				if (reciveTO.getTipoError() != TransferObject.INFO) {
					// dar de baja registros de responsable y crear registros de
					// bitacora responsable
					for (int x = 0; x < reciveTO.getListIdResponsable().length; x++) {

						short res = (Short) ConexionConPersistencia
								.invocaServicio("desactivaResponsable",
										reciveTO.getListIdResponsable()[x],
										Short.class);

						if (res != (short) 1) {
							x--;
						} else {
							BitacoraResponsableTO bitacoraResponsableTO = new BitacoraResponsableTO();
							bitacoraResponsableTO.setIdResponsable(reciveTO
									.getListIdResponsable()[x]);
							bitacoraResponsableTO
									.setIdEmpleadoJefe(reciveTO
											.getListEmpleadoJefeTO()[0]
											.getIdEmpleado());
							bitacoraResponsableTO
									.setIdEmpleadoSubordinado(reciveTO
											.getListEmpleadoSubordinadoTO()[x]
											.getIdEmpleado());
							bitacoraResponsableTO.setActivo(false);
							bitacoraResponsableTO
									.setFecha(new java.util.Date());

							boolean res2 = (Boolean) ConexionConPersistencia
									.invocaServicio(
											"agregarBitacoraResponsable",
											bitacoraResponsableTO,
											Boolean.class);

							if (res2 == false)
								x--;
						}

					}
				} else {
					// tiene empleado subordinados
					auxTO = new EmpleadoTO();
					auxTO.setTipoError(TransferObject.INFO);
					auxTO.setError(CodigosDeError.error.get(32003));
					return auxTO;
				}
			} else {
				// no hay conexion con persistencia
				auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(31010));
				return auxTO;
			}

		} else {

			reciveTO = (ResponsableTO) ConexionConPersistencia.invocaServicio(
					"encontrarEmpleadosActivosPorJefe", bajaTO.getIdEmpleado(),
					ResponsableTO.class);

			if (reciveTO != null) {
				if (reciveTO.getTipoError() == TransferObject.INFO) {
					// no tiene emmpleado subordinados
					bandera1 = true;
				} else {
					// tiene empleados subordinados
					auxTO = new EmpleadoTO();
					auxTO.setTipoError(TransferObject.CONFIRMACION);
					auxTO.setError(CodigosDeError.error.get(32003));
					return auxTO;
				}
			} else {
				// no hay conexion con persistencia
				auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(31010));
				return auxTO;
			}
		}
		if (bandera1 == true) {

			auxTO = new EmpleadoTO();
			boolean res2 = false;

			short res = (Short) ConexionConPersistencia.invocaServicio(
					"desactivaEmpleado", bajaTO.getIdEmpleado(), Short.class);

			if (res == 1) {

				BitacoraEmpleadoTO bitacoraEmpleadoTO = new BitacoraEmpleadoTO();
				bitacoraEmpleadoTO.setEmpleadoTO(bajaTO);

				bitacoraEmpleadoTO.setFecha(new java.util.Date());

				res2 = (Boolean) ConexionConPersistencia.invocaServicio(
						"agregarBitacoraEmpleado", bitacoraEmpleadoTO,
						Boolean.class);

			}
			if (res != 1 || res2 == false) {
				auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(31010));
			} else {
				auxTO = new EmpleadoTO();
				auxTO.setError(CodigosDeError.error.get(32004));
			}
		}
		return auxTO;
	}

	public static EmpleadoTO agregarEmpleado(EmpleadoTO[] arrEmpleadoTO) {
		EmpleadoTO auxTO = null;
		EmpleadoTO reciveEmpTO = null;
		int bandera = -1;
		PersonaTO recivePerTO = null;
		auxTO = new EmpleadoTO();
		auxTO.setTipoError(1);
		reciveEmpTO = (EmpleadoTO) ConexionConPersistencia.invocaServicio(
				"encontrarEmpleadoActivoPorNss", arrEmpleadoTO[0].getNss(),
				EmpleadoTO.class);
		if (reciveEmpTO != null) {
			if (reciveEmpTO.getTipoError() == 0) {
				// Existe un empleado con ese NSS
				auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.INFO);
				auxTO.setError(CodigosDeError.error.get(32005));
			} else {
				// No hay empleados con el NSS
				recivePerTO = (PersonaTO) ConexionConPersistencia
						.invocaServicio("encontrarPersonaPorCURP",
								arrEmpleadoTO[0].getPersonaTO().getCurp(),
								PersonaTO.class);

				if (recivePerTO != null) {

					if (recivePerTO.getTipoError() > 0) {
						// no existe la persona registrada en la base de datos,
						// asi que se crea el
						// registro de direccion,
						// Persona,Empleado,BitacoraEmpleado,Responsable,
						// BitacoraRespnsable
						bandera = 1;
					} else {
						// existe la persona registrada en la base de datos, asi
						// que se actualiza el
						// registro de Persona y se crea el de
						// Empleado,BitacoraEmpleado,Responsable,
						// BitacoraRespnsable
						arrEmpleadoTO[0].getPersonaTO().setIdPersona(
								recivePerTO.getIdPersona());
						bandera = 2;
					}

					if (bandera == 1 || bandera == 2) {

						boolean res = false;
						boolean res1 = false;
						boolean res2 = false;
						boolean res3 = false;
						boolean res4 = false;
						boolean res5 = false;
						PersonaTO nuevaPerTO = null;
						EmpleadoTO nuevoEmpTO = null;
						ResponsableTO nuevoResTO = null;
						DireccionTO nuevaDirTO = null;

						if (bandera == 1) {

							res1 = (Boolean) ConexionConPersistencia
									.invocaServicio("agregarDireccion",
											arrEmpleadoTO[0].getPersonaTO()
													.getDireccionTO(),
											Boolean.class);

							if (res1 == true) {

								nuevaDirTO = (DireccionTO) ConexionConPersistencia
										.invocaServicio(
												"encontrarDireccionPorNumeroInteriorColoniaCalle",
												arrEmpleadoTO[0].getPersonaTO()
														.getDireccionTO(),
												DireccionTO.class);
								if (nuevaDirTO.getTipoError() == 0) {

									arrEmpleadoTO[0].getPersonaTO()
											.setDireccionTO(nuevaDirTO);

									res = (Boolean) ConexionConPersistencia
											.invocaServicio("agregarPersona",
													arrEmpleadoTO[0]
															.getPersonaTO(),
													Boolean.class);
								}
							}

						} else {

							short respuesta;
							short respuesta2;

							if (recivePerTO.getDireccionTO()
									.getColoniaCalleTO().getIdColoniaCalle() == arrEmpleadoTO[0]
									.getPersonaTO().getDireccionTO()
									.getColoniaCalleTO().getIdColoniaCalle()
									&& recivePerTO.getDireccionTO().getNumero()
											.compareTo(
													arrEmpleadoTO[0]
															.getPersonaTO()
															.getDireccionTO()
															.getNumero()) == 0
									&& recivePerTO.getDireccionTO()
											.getInterior().compareTo(
													arrEmpleadoTO[0]
															.getPersonaTO()
															.getDireccionTO()
															.getInterior()) == 0) {

								// si la direccion es la misma solo se actualiza

								arrEmpleadoTO[0].getPersonaTO()
										.getDireccionTO().setIdDireccion(
												recivePerTO.getDireccionTO()
														.getIdDireccion());

								respuesta2 = (Short) ConexionConPersistencia
										.invocaServicio("modificarDireccion",
												arrEmpleadoTO[0].getPersonaTO()
														.getDireccionTO(),
												Short.class);

								if (respuesta2 == 1) {
									res1 = true;
								}

							} else {
								// si la direccion no es la misma se crea un
								// registro
								res1 = (Boolean) ConexionConPersistencia
										.invocaServicio("agregarDireccion",
												arrEmpleadoTO[0].getPersonaTO()
														.getDireccionTO(),
												Boolean.class);
								nuevaDirTO = (DireccionTO) ConexionConPersistencia
										.invocaServicio(
												"encontrarDireccionPorNumeroInteriorColoniaCalle",
												arrEmpleadoTO[0].getPersonaTO()
														.getDireccionTO(),
												DireccionTO.class);

								if (nuevaDirTO.getTipoError() == 0) {
									// se busca la direccion que se acaba de
									// registrar para poder actualizar los datos
									// de persona

									arrEmpleadoTO[0].getPersonaTO()
											.setDireccionTO(nuevaDirTO);
								} else
									res1 = false;
							}

							if (res1 == true) {
								// si no existio error al crear o modificar la
								// direccion entonces se modifican los datos de
								// persona

								respuesta = (Short) ConexionConPersistencia
										.invocaServicio(
												"modificarPersona",
												arrEmpleadoTO[0].getPersonaTO(),
												Short.class);

								if (respuesta == 1) {
									res = true;
								}
							}
						}
						if (res == true) {

							nuevaPerTO = (PersonaTO) ConexionConPersistencia
									.invocaServicio("encontrarPersonaPorCURP",
											arrEmpleadoTO[0].getPersonaTO()
													.getCurp(), PersonaTO.class);

							if (nuevaPerTO.getTipoError() == 0) {
								// se crea el registro de empleado

								arrEmpleadoTO[0].setPersonaTO(nuevaPerTO);

								res2 = (Boolean) ConexionConPersistencia
										.invocaServicio("agregarEmpleado",
												arrEmpleadoTO[0], Boolean.class);
								if (res2 == true) {
									nuevoEmpTO = (EmpleadoTO) ConexionConPersistencia
											.invocaServicio(
													"encontrarEmpleadoActivoPorNss",
													arrEmpleadoTO[0].getNss(),
													EmpleadoTO.class);

									if (nuevoEmpTO.getTipoError() == 0) {
										// se crea el registro de
										// BitacoraEmpleado

										arrEmpleadoTO[0] = nuevoEmpTO;
										if (arrEmpleadoTO[1].getIdEmpleado() == -1)
											arrEmpleadoTO[1] = nuevoEmpTO;

										BitacoraEmpleadoTO bitacoraEmpleadoTO = new BitacoraEmpleadoTO();

										bitacoraEmpleadoTO
												.setEmpleadoTO(nuevoEmpTO);
										bitacoraEmpleadoTO
												.setFecha(new java.util.Date());

										res3 = (Boolean) ConexionConPersistencia
												.invocaServicio(
														"agregarBitacoraEmpleado",
														bitacoraEmpleadoTO,
														Boolean.class);

										if (res3 == true) {
											// se crea el registro Responsable

											ResponsableTO responsableTO = new ResponsableTO();
											responsableTO
													.setIdEmpleadoJefe(arrEmpleadoTO[1]
															.getIdEmpleado());
											responsableTO
													.setIdEmpleadoSubordinado(nuevoEmpTO
															.getIdEmpleado());
											responsableTO.setActivo(true);

											res4 = (Boolean) ConexionConPersistencia
													.invocaServicio(
															"agregarResponsable",
															responsableTO,
															Boolean.class);

											if (res4 == true) {
												// Se crea el Registro de
												// BitacoraResponsable

												nuevoResTO = (ResponsableTO) ConexionConPersistencia
														.invocaServicio(
																"encontrarJefeActivoPorSubordinado",
																arrEmpleadoTO[0]
																		.getIdEmpleado(),
																ResponsableTO.class);

												if (nuevoResTO.getTipoError() == 0) {

													BitacoraResponsableTO bitacoraResponsableTO = new BitacoraResponsableTO();
													bitacoraResponsableTO
															.setIdResponsable(nuevoResTO
																	.getListIdResponsable()[0]);
													bitacoraResponsableTO
															.setIdEmpleadoJefe(nuevoResTO
																	.getListEmpleadoJefeTO()[0]
																	.getIdEmpleado());
													bitacoraResponsableTO
															.setIdEmpleadoSubordinado(nuevoResTO
																	.getListEmpleadoSubordinadoTO()[0]
																	.getIdEmpleado());
													bitacoraResponsableTO
															.setActivo(true);
													bitacoraResponsableTO
															.setFecha(new java.util.Date());

													res5 = (Boolean) ConexionConPersistencia
															.invocaServicio(
																	"agregarBitacoraResponsable",
																	bitacoraResponsableTO,
																	Boolean.class);
												}

											}
										}
									}
								}
							}
							if (res == false || res1 == false || res2 == false
									|| res3 == false || res4 == false
									|| res5 == false) {
								// ocurrio un error en el intento de registrar

								auxTO = new EmpleadoTO();
								auxTO.setTipoError(TransferObject.ERROR);
								auxTO.setError(CodigosDeError.error.get(31010));
							} else {
								// se dio de alta satisfactoriamente
								auxTO = new EmpleadoTO();
								auxTO.setError(CodigosDeError.error.get(32006));
							}

						}
					}
				} else {
					auxTO = new EmpleadoTO();
					auxTO.setTipoError(TransferObject.ERROR);
					auxTO.setError(CodigosDeError.error.get(31010));
				}
			}
		} else {
			auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.ERROR);
			auxTO.setError(CodigosDeError.error.get(31010));
		}
		return auxTO;
	}

	public static EmpleadoTO modificarEmpleado(EmpleadoTO[] arrEmpleadoTO) {
		EmpleadoTO auxTO = null;
		boolean mEmpleado = false;
		boolean mPersona = false;
		boolean mDireccion = false;
		boolean mJefe = false;
		boolean mPuesto = false;
		DireccionTO nDireccionTO = null;
		PersonaTO nPersonaTO = null;
		EmpleadoTO nEmpleadoTO = null;
		boolean bandera = false;
		boolean bandera1 = false;
		boolean bandera2 = false;
		boolean bandera3 = true;

		arrEmpleadoTO[0].setIdEmpleado(arrEmpleadoTO[2].getIdEmpleado());
		arrEmpleadoTO[0].getPersonaTO().setIdPersona(
				arrEmpleadoTO[2].getPersonaTO().getIdPersona());
		arrEmpleadoTO[0].getPersonaTO().getDireccionTO().setIdDireccion(
				arrEmpleadoTO[2].getPersonaTO().getDireccionTO()
						.getIdDireccion());

		// si no se pone a ningun jefe, entonces se pone al amplado como a si
		// mismo como jefe
		if (arrEmpleadoTO[1].getIdEmpleado() == -1) {
			arrEmpleadoTO[1].setIdEmpleado(arrEmpleadoTO[0].getIdEmpleado());
		}

		if (arrEmpleadoTO[0].getNss().compareTo(arrEmpleadoTO[2].getNss()) != 0) {
			mEmpleado = true;
		} else {
			arrEmpleadoTO[0].setIdEmpleado(arrEmpleadoTO[2].getIdEmpleado());
		}

		if (arrEmpleadoTO[0].getPersonaTO().getCurp().compareTo(
				arrEmpleadoTO[2].getPersonaTO().getCurp()) != 0) {
			mPersona = true;
		} else {
			arrEmpleadoTO[0].getPersonaTO().setIdPersona(
					arrEmpleadoTO[2].getPersonaTO().getIdPersona());
		}

		if (arrEmpleadoTO[2].getPersonaTO().getDireccionTO()
				.getColoniaCalleTO().getIdColoniaCalle() == arrEmpleadoTO[0]
				.getPersonaTO().getDireccionTO().getColoniaCalleTO()
				.getIdColoniaCalle()
				&& arrEmpleadoTO[2].getPersonaTO().getDireccionTO().getNumero()
						.compareTo(
								arrEmpleadoTO[0].getPersonaTO()
										.getDireccionTO().getNumero()) == 0
				&& arrEmpleadoTO[2].getPersonaTO().getDireccionTO()
						.getInterior().compareTo(
								arrEmpleadoTO[0].getPersonaTO()
										.getDireccionTO().getInterior()) == 0) {

			arrEmpleadoTO[0].getPersonaTO().getDireccionTO().setIdDireccion(
					arrEmpleadoTO[2].getPersonaTO().getDireccionTO()
							.getIdDireccion());
		} else {
			mDireccion = true;
		}
		if (arrEmpleadoTO[0].getPuestoTO().getIdPuesto() != arrEmpleadoTO[2]
				.getPuestoTO().getIdPuesto()) {
			mPuesto = true;
		}
		if (arrEmpleadoTO[1].getIdEmpleado() != arrEmpleadoTO[3]
				.getIdEmpleado()) {
			mJefe = true;
		}

		// ********** actualizacion de la direccion, se actualiza si se modifico
		// *****************************/
		if (mDireccion == false) {
			// solo se actualizan los datos

			short res = (Short) ConexionConPersistencia.invocaServicio(
					"modificarDireccion", arrEmpleadoTO[0].getPersonaTO()
							.getDireccionTO(), Short.class);

			if (res == 1) {
				bandera = true;
			}
		} else {
			// se busca la direccion, si no existe, se crea una nueva, si existe
			// se relaciona con la persona
			nDireccionTO = (DireccionTO) ConexionConPersistencia
					.invocaServicio(
							"encontrarDireccionPorNumeroInteriorColoniaCalle",
							arrEmpleadoTO[0].getPersonaTO().getDireccionTO(),
							DireccionTO.class);

			if (nDireccionTO.getTipoError() == 0) {
				// existia la direccion en la base
				arrEmpleadoTO[0].getPersonaTO().getDireccionTO()
						.setIdDireccion(nDireccionTO.getIdDireccion());
				bandera = true;
			} else {
				// no existia la direccion
				bandera = (Boolean) ConexionConPersistencia.invocaServicio(
						"agregarDireccion", arrEmpleadoTO[0].getPersonaTO()
								.getDireccionTO(), Boolean.class);

				nDireccionTO = (DireccionTO) ConexionConPersistencia
						.invocaServicio(
								"encontrarDireccionPorNumeroInteriorColoniaCalle",
								arrEmpleadoTO[0].getPersonaTO()
										.getDireccionTO(), DireccionTO.class);

				if (nDireccionTO.getTipoError() == 0) {
					// Se relaciona el id de la nueva direccion con la persona
					arrEmpleadoTO[0].getPersonaTO().getDireccionTO()
							.setIdDireccion(nDireccionTO.getIdDireccion());
					bandera = true;
				} else {
					bandera = false;
				}
			}
		}

		// *************************** actualizacion a los datos de la
		// persona*********************************/
		if (mPersona == false) {
			// actualizacion de datos si es que se encontro que no habia
			// modificacion en los datos no nulos
			short respuesta;

			respuesta = (Short) ConexionConPersistencia.invocaServicio(
					"modificarPersona", arrEmpleadoTO[0].getPersonaTO(),
					Short.class);

			if (respuesta == 1) {
				bandera1 = true;
			}
		} else {
			// // se busca la persona, si no existe, se crea el registro, si
			// existe se virifica que no este relacionada con otra persona
			// empleado, si no esta relacinada se relaciona con la persona
			// actual

			nPersonaTO = (PersonaTO) ConexionConPersistencia.invocaServicio(
					"encontrarPersonaPorCURP", arrEmpleadoTO[0].getPersonaTO()
							.getCurp(), PersonaTO.class);

			if (nPersonaTO.getTipoError() > 0) {
				// no existen datos registrados de la persona, asi que se crea
				// un nuevo registro y se relaciona con el empleado

				bandera1 = (Boolean) ConexionConPersistencia.invocaServicio(
						"agregarPersona", arrEmpleadoTO[0].getPersonaTO(),
						Boolean.class);

				if (bandera1 == true) {
					// se busca el registro que se acaba de dar de alta para
					// obtener el id_persona

					nPersonaTO = (PersonaTO) ConexionConPersistencia
							.invocaServicio("encontrarPersonaPorCURP",
									arrEmpleadoTO[0].getPersonaTO().getCurp(),
									PersonaTO.class);

					if (nPersonaTO.getTipoError() == 0) {
						arrEmpleadoTO[0].getPersonaTO().setIdPersona(
								nPersonaTO.getIdPersona());
					} else {
						bandera1 = false;
					}
				}
			} else {
				// Si existen registros de la persona con ese curp, asi que se
				// verifica si no esta relacionada actualmente con otro empleado

				nEmpleadoTO = (EmpleadoTO) ConexionConPersistencia
						.invocaServicio("encontrarEmpleadoActivoPorCURP",
								arrEmpleadoTO[0].getPersonaTO().getCurp(),
								EmpleadoTO.class);

				if (nEmpleadoTO.getTipoError() == 0
						&& arrEmpleadoTO[0].getIdEmpleado() != nEmpleadoTO
								.getIdEmpleado()) {

					// existe otro empleado activo con ese curp
					auxTO = new EmpleadoTO();
					auxTO.setTipoError(TransferObject.ERROR);
					auxTO.setError(CodigosDeError.error.get(32009));
					return auxTO;
				} else {
					// no existe otro empleado relacionado con el curp, asi que
					// se relaciona al empleado actual
					arrEmpleadoTO[0].getPersonaTO().setIdPersona(
							nPersonaTO.getIdPersona());
					bandera1 = true;
				}
			}

		}
		/**
		 * **************actualizacion de los datos del empleado
		 * ***********************************************
		 */
		if (mEmpleado == false) {
			// no se modificaron los datos del empleado asi que solo se
			// actualizan
			short respuesta;

			respuesta = (Short) ConexionConPersistencia.invocaServicio(
					"modificarEmpleado", arrEmpleadoTO[0], Short.class);

			if (respuesta == 1) {
				bandera2 = true;
			}
		} else {
			nEmpleadoTO = null;
			nEmpleadoTO = (EmpleadoTO) ConexionConPersistencia.invocaServicio(
					"encontrarEmpleadoActivoPorNss", arrEmpleadoTO[0].getNss(),
					EmpleadoTO.class);

			if (nEmpleadoTO.getTipoError() > 0
					|| arrEmpleadoTO[0].getIdEmpleado() == nEmpleadoTO
							.getIdEmpleado()) {

				short respuesta = (Short) ConexionConPersistencia
						.invocaServicio("modificarEmpleado", arrEmpleadoTO[0],
								Short.class);
				if (respuesta == 1) {
					bandera2 = true;
				}
			} else {
				auxTO = new EmpleadoTO();
				auxTO.setTipoError(TransferObject.ERROR);
				auxTO.setError(CodigosDeError.error.get(32008) + " "
						+ arrEmpleadoTO[0].getIdEmpleado() + " "
						+ nEmpleadoTO.getIdEmpleado());
				return auxTO;
			}
		}

		// Se modificaron los datos del empleado, por lo que se realizan
		// cambios a las bitacoras y/o responsable

		if (mPuesto == true) {
			BitacoraEmpleadoTO bitacoraEmpleadoTO = new BitacoraEmpleadoTO();
			bitacoraEmpleadoTO.setEmpleadoTO(arrEmpleadoTO[0]);
			bitacoraEmpleadoTO.setFecha(new java.util.Date());

			bandera2 = (Boolean) ConexionConPersistencia.invocaServicio(
					"agregarBitacoraEmpleado", bitacoraEmpleadoTO,
					Boolean.class);
		}
		if (mJefe == true) {
			short resultado;
			EmpleadoTO[] arrjefeSubordinadoTO = new EmpleadoTO[2];
			arrjefeSubordinadoTO[0] = arrEmpleadoTO[3];
			arrjefeSubordinadoTO[1] = arrEmpleadoTO[2];
			ResponsableTO nResponsableTO = (ResponsableTO) ConexionConPersistencia
					.invocaServicio(
							"encontrarResponsableActivoPorJefeySubordinado",
							arrjefeSubordinadoTO, ResponsableTO.class);

			if (nResponsableTO.getTipoError() == 0) {
				boolean ban = false;
				resultado = (Short) ConexionConPersistencia.invocaServicio(
						"desactivaResponsable", nResponsableTO
								.getIdResponsable(), Short.class);

				// se crea el registro de baja de bitacora responsable de la
				// operacion anterior

				BitacoraResponsableTO bitacoraResponsableTO = new BitacoraResponsableTO();
				bitacoraResponsableTO.setIdResponsable(nResponsableTO
						.getIdResponsable());
				bitacoraResponsableTO.setIdEmpleadoJefe(arrEmpleadoTO[3]
						.getIdEmpleado());
				bitacoraResponsableTO.setIdEmpleadoSubordinado(arrEmpleadoTO[2]
						.getIdEmpleado());
				bitacoraResponsableTO.setActivo(false);
				bitacoraResponsableTO.setFecha(new java.util.Date());

				bandera3 = (Boolean) ConexionConPersistencia.invocaServicio(
						"agregarBitacoraResponsable", bitacoraResponsableTO,
						Boolean.class);

				if (resultado == 1 && bandera3 == true) {
					// se crea el registro de la nueva relacion
					// jefeSubordinado

					nResponsableTO = null;
					nResponsableTO = new ResponsableTO();
					nResponsableTO.setIdEmpleadoJefe(arrEmpleadoTO[1]
							.getIdEmpleado());
					nResponsableTO.setIdEmpleadoSubordinado(arrEmpleadoTO[0]
							.getIdEmpleado());
					nResponsableTO.setActivo(true);

					ban = (Boolean) ConexionConPersistencia
							.invocaServicio("agregarResponsable",
									nResponsableTO, Boolean.class);

					if (ban == true) {
						EmpleadoTO[] jefeSubordinadoTO = new EmpleadoTO[2];
						jefeSubordinadoTO[0] = arrEmpleadoTO[1];
						jefeSubordinadoTO[1] = arrEmpleadoTO[0];

						nResponsableTO = null;
						nResponsableTO = (ResponsableTO) ConexionConPersistencia
								.invocaServicio(
										"encontrarResponsableActivoPorJefeySubordinado",
										jefeSubordinadoTO, ResponsableTO.class);

						if (nResponsableTO.getTipoError() == 0) {

							bitacoraResponsableTO = null;
							bitacoraResponsableTO = new BitacoraResponsableTO();
							bitacoraResponsableTO
									.setIdResponsable(nResponsableTO
											.getIdResponsable());
							bitacoraResponsableTO
									.setIdEmpleadoJefe(arrEmpleadoTO[1]
											.getIdEmpleado());
							bitacoraResponsableTO
									.setIdEmpleadoSubordinado(arrEmpleadoTO[0]
											.getIdEmpleado());
							bitacoraResponsableTO.setActivo(true);
							bitacoraResponsableTO
									.setFecha(new java.util.Date());

							bandera3 = (Boolean) ConexionConPersistencia
									.invocaServicio(
											"agregarBitacoraResponsable",
											bitacoraResponsableTO,
											Boolean.class);
						}
					}

				}
			}

		}

		if (bandera == true && bandera1 == true && bandera2 == true) {
			auxTO = new EmpleadoTO();
			auxTO.setError(CodigosDeError.error.get(32007));
		} else {
			auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.ERROR);
			auxTO.setError(CodigosDeError.error.get(31010));
		}
		if (bandera3 == false) {
			auxTO = new EmpleadoTO();
			auxTO.setTipoError(TransferObject.ERROR);
			auxTO.setError(CodigosDeError.error.get(32010));
		}

		return auxTO;

	}

	public static EmpleadoTO encontrarEmpleadoPorID(int idEmpleado) {
		EmpleadoTO empleadoTO = (EmpleadoTO) ConexionConPersistencia
				.invocaServicio("encontrarEmpleadoPorID", idEmpleado,
						EmpleadoTO.class);
		if (empleadoTO != null) {
			if (empleadoTO.getTipoError() != 0) {
				empleadoTO.setTipoError(TransferObject.ERROR);
				empleadoTO.setError(CodigosDeError.error.get(33001));
			}
		} else {
			empleadoTO = new EmpleadoTO();
			empleadoTO.setTipoError(TransferObject.ERROR);
			empleadoTO.setError(CodigosDeError.error.get(33002));
		}
		return empleadoTO;
	}

	public static UsuarioTO[] encontrarUsuariosPorActivo(boolean activo) {
		UsuarioTO[] arrUsuarioTO = (UsuarioTO[]) ConexionConPersistencia
				.invocaServicio("encontrarUsuariosPorActivo", activo,
						UsuarioTO[].class);
		if (arrUsuarioTO != null) {
			if (arrUsuarioTO[0].getTipoError() != 0) {
				arrUsuarioTO[0].setTipoError(TransferObject.INFO);
				arrUsuarioTO[0].setError(CodigosDeError.error.get(33003));
			}
		} else {
			arrUsuarioTO = new UsuarioTO[1];
			arrUsuarioTO[0] = new UsuarioTO();
			arrUsuarioTO[0].setTipoError(TransferObject.ERROR);
			arrUsuarioTO[0].setError(CodigosDeError.error.get(33002));
		}
		return arrUsuarioTO;
	}

	public static GrupoUsuarioTO[] ObtenerGruposDeUsuario() {

		GrupoUsuarioTO[] arrGrupoUsuarioTO = (GrupoUsuarioTO[]) ConexionConPersistencia
				.invocaServicio("ObtenerGruposDeUsuario",
						GrupoUsuarioTO[].class);

		if (arrGrupoUsuarioTO != null) {
			if (arrGrupoUsuarioTO[0].getTipoError() != 0) {
				arrGrupoUsuarioTO[0].setTipoError(TransferObject.ERROR);
				arrGrupoUsuarioTO[0].setError(CodigosDeError.error.get(33004));
			}
		} else {
			arrGrupoUsuarioTO = new GrupoUsuarioTO[1];
			arrGrupoUsuarioTO[0] = new GrupoUsuarioTO();
			arrGrupoUsuarioTO[0].setTipoError(TransferObject.ERROR);
			arrGrupoUsuarioTO[0].setError(CodigosDeError.error.get(33002));
		}
		return arrGrupoUsuarioTO;
	}

	public static UsuarioTO[] encontrarUsuariosPorGrupo(short idGrupoUsuario) {
		UsuarioTO[] arrUsuarioTO = (UsuarioTO[]) ConexionConPersistencia
				.invocaServicio("encontrarUsuariosPorGrupo", idGrupoUsuario,
						UsuarioTO[].class);
		if (arrUsuarioTO != null) {
			if (arrUsuarioTO[0].getTipoError() != 0) {
				arrUsuarioTO[0].setTipoError(TransferObject.INFO);
				arrUsuarioTO[0].setError(CodigosDeError.error.get(33005));
			}
		} else {
			arrUsuarioTO = new UsuarioTO[1];
			arrUsuarioTO[0] = new UsuarioTO();
			arrUsuarioTO[0].setTipoError(TransferObject.ERROR);
			arrUsuarioTO[0].setError(CodigosDeError.error.get(33002));
		}
		return arrUsuarioTO;
	}

	public static UsuarioTO[] obtenerUsuarios() {
		UsuarioTO[] arrUsuarioTO = (UsuarioTO[]) ConexionConPersistencia
				.invocaServicio("obtenerUsuarios", UsuarioTO[].class);
		if (arrUsuarioTO != null) {
			if (arrUsuarioTO[0].getTipoError() != 0) {
				arrUsuarioTO[0].setTipoError(TransferObject.INFO);
				arrUsuarioTO[0].setError(CodigosDeError.error.get(33006));
			}
		} else {
			arrUsuarioTO = new UsuarioTO[1];
			arrUsuarioTO[0] = new UsuarioTO();
			arrUsuarioTO[0].setTipoError(TransferObject.ERROR);
			arrUsuarioTO[0].setError(CodigosDeError.error.get(33002));
		}
		return arrUsuarioTO;
	}

	public static UsuarioTO[] encontrarUsuarioPorNombre(String nombreUsuario) {
		UsuarioTO[] arrUsuarioTO = new UsuarioTO[1];

		UsuarioTO reciveTO = (UsuarioTO) ConexionConPersistencia
				.invocaServicio("encontrarUsuarioPorNombre", nombreUsuario,
						UsuarioTO.class);
		if (reciveTO != null) {
			if (reciveTO.getTipoError() != 0) {
				reciveTO.setTipoError(TransferObject.INFO);
				reciveTO.setError(CodigosDeError.error.get(33007));
				arrUsuarioTO[0] = reciveTO;
			} else {
				arrUsuarioTO[0] = reciveTO;
			}
		} else {
			reciveTO = new UsuarioTO();
			reciveTO.setTipoError(TransferObject.INFO);
			reciveTO.setError(CodigosDeError.error.get(33002));
			arrUsuarioTO[0] = reciveTO;
		}
		return arrUsuarioTO;
	}

	public static UsuarioTO[] encontrarEmpleadoPorNssActivoEInactivo(String nss) {
		UsuarioTO[] arrUsuarioTO = new UsuarioTO[1];
		UsuarioTO reciveTO = null;
		EmpleadoTO empleadoTO = (EmpleadoTO) ConexionConPersistencia
				.invocaServicio("encontrarEmpleadoPorNssActivoEInactivo", nss,
						UsuarioTO.class);
		if (empleadoTO != null) {
			if (empleadoTO.getTipoError() == 0) {
				reciveTO = (UsuarioTO) ConexionConPersistencia.invocaServicio(
						"encontrarUsuarioPorIdEmpleado", empleadoTO
								.getIdEmpleado(), UsuarioTO.class);

				if (reciveTO != null) {
					if (reciveTO.getTipoError() != 0) {
						reciveTO.setTipoError(TransferObject.INFO);
						reciveTO.setError(CodigosDeError.error.get(33008));
						arrUsuarioTO[0] = reciveTO;
					} else {
						arrUsuarioTO[0] = reciveTO;
					}
				} else {
					reciveTO = new UsuarioTO();
					reciveTO.setTipoError(TransferObject.INFO);
					reciveTO.setError(CodigosDeError.error.get(33002));
					arrUsuarioTO[0] = reciveTO;
				}
			} else {
				reciveTO = new UsuarioTO();
				reciveTO.setTipoError(TransferObject.INFO);
				reciveTO.setError(CodigosDeError.error.get(33008));
				arrUsuarioTO[0] = reciveTO;
			}
		} else {
			reciveTO = new UsuarioTO();
			reciveTO.setTipoError(TransferObject.INFO);
			reciveTO.setError(CodigosDeError.error.get(33002));
			arrUsuarioTO[0] = reciveTO;
		}

		return arrUsuarioTO;
	}

	public static UsuarioTO agregarUsuarioTO(UsuarioTO usuarioTO) {
		UsuarioTO respuestaTO = null;

		UsuarioTO busquedaTO = (UsuarioTO) ConexionConPersistencia
				.invocaServicio("encontrarUsuarioPorNombre", usuarioTO
						.getNombreUsuario(), UsuarioTO.class);

		if (busquedaTO != null) {
			if (busquedaTO.getTipoError() != 0) {
				try {
					int indiceRespuesta = (Integer) ConexionConPersistencia
							.invocaServicio("agregarUsuario", usuarioTO,
									Integer.class);
					if (indiceRespuesta > 0) {
						respuestaTO = new UsuarioTO();
						respuestaTO.setError(CodigosDeError.error.get(33010));
					} else {
						respuestaTO = new UsuarioTO();
						respuestaTO.setTipoError(TransferObject.INFO);
						respuestaTO.setError(CodigosDeError.error.get(33011));
					}
				} catch (Exception e) {
					respuestaTO = new UsuarioTO();
					respuestaTO.setTipoError(TransferObject.ERROR);
					respuestaTO.setError(CodigosDeError.error.get(33002));
				}
			} else {
				respuestaTO = new UsuarioTO();
				respuestaTO.setTipoError(TransferObject.ERROR);
				respuestaTO.setError(CodigosDeError.error.get(33009));
			}
		} else {
			respuestaTO = new UsuarioTO();
			respuestaTO.setTipoError(TransferObject.ERROR);
			respuestaTO.setError(CodigosDeError.error.get(33002));
		}

		return respuestaTO;
	}

	public static UsuarioTO modificarUsuarioTO(UsuarioTO usuarioTO) {
		UsuarioTO respuestaTO = null;

		UsuarioTO busquedaTO = (UsuarioTO) ConexionConPersistencia
				.invocaServicio("encontrarUsuarioPorNombre", usuarioTO
						.getNombreUsuario(), UsuarioTO.class);

		if (busquedaTO != null) {
			if (busquedaTO.getTipoError() == 0
					&& usuarioTO.getIdUsuario() != busquedaTO.getIdUsuario()) {
				respuestaTO = new UsuarioTO();
				respuestaTO.setTipoError(TransferObject.ERROR);
				respuestaTO.setError(CodigosDeError.error.get(33009));
			} else {

				try {
					short indiceRespuesta = (Short) ConexionConPersistencia
							.invocaServicio("modificarUsuario", usuarioTO,
									Short.class);
					if (indiceRespuesta == 1) {
						respuestaTO = new UsuarioTO();
						respuestaTO.setError(CodigosDeError.error.get(33012));
					} else {
						respuestaTO = new UsuarioTO();
						respuestaTO.setTipoError(TransferObject.INFO);
						respuestaTO.setError(CodigosDeError.error.get(33013));
					}
				} catch (Exception e) {
					respuestaTO = new UsuarioTO();
					respuestaTO.setTipoError(TransferObject.ERROR);
					respuestaTO.setError(CodigosDeError.error.get(33002));
				}
			}
		} else {
			respuestaTO = new UsuarioTO();
			respuestaTO.setTipoError(TransferObject.ERROR);
			respuestaTO.setError(CodigosDeError.error.get(33002));
		}

		return respuestaTO;
	}

	public static UsuarioTO activarDesactivarUsuarioTO(UsuarioTO usuarioTO) {
		UsuarioTO respuestaTO = null;

		if (usuarioTO.getActivo() == true)
			usuarioTO.setActivo(false);
		else
			usuarioTO.setActivo(true);

		try {
			short resultado = (Short) ConexionConPersistencia.invocaServicio(
					"modificarUsuario", usuarioTO, Short.class);
			if (resultado == (short) 1) {
				respuestaTO = new UsuarioTO();
				respuestaTO.setError(CodigosDeError.error.get(33012));
			} else {
				respuestaTO = new UsuarioTO();
				respuestaTO.setTipoError(TransferObject.INFO);
				respuestaTO.setError(CodigosDeError.error.get(33013));
			}
		} catch (Exception e) {
			respuestaTO = new UsuarioTO();
			respuestaTO.setTipoError(TransferObject.ERROR);
			respuestaTO.setError(CodigosDeError.error.get(33002));
		}

		return respuestaTO;
	}

}
